.TH std::experimental::ostream_joiner 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::experimental::ostream_joiner \- std::experimental::ostream_joiner

.SH Synopsis
   Defined in header <experimental/iterator>
   template<

       class DelimT,
       class CharT = char,                     (library fundamentals TS v2)
       class Traits = std::char_traits<CharT>
   >

   class ostream_joiner;

   std::experimental::ostream_joiner is a single-pass LegacyOutputIterator that writes
   successive objects into the std::basic_ostream object for which it was constructed,
   using operator<<, separated by a delimiter. The delimiter is written to the output
   stream between every two objects that are written. The write operation is performed
   when the iterator (whether dereferenced or not) is assigned to. Incrementing the
   ostream_joiner is a no-op.

   In a typical implementation, the only data members of ostream_joiner are a pointer
   to the associated std::basic_ostream, the delimiter, and a bool member that
   indicates whether the next write is for the first element in the sequence.

   Compared to std::ostream_iterator, ostream_joiner prints the delimiter sequence one
   fewer time, and is not templated on the type of the object to be printed.

.SH Member types

   Member type       Definition
   char_type         CharT
   traits_type       Traits
   ostream_type      std::basic_ostream<CharT, Traits>
   value_type        void
   difference_type   void
   pointer           void
   reference         void
   iterator_category std::output_iterator_tag

.SH Member functions

   constructor           constructs a new ostream_joiner
                         \fI(public member function)\fP
   destructor            destructs an ostream_joiner
   (implicitly declared) \fI(public member function)\fP
   operator=             writes an object to the associated output sequence
                         \fI(public member function)\fP
   operator*             no-op
                         \fI(public member function)\fP
   operator++            no-op
   operator++(int)       \fI(public member function)\fP

.SH Non-member functions

                       creates an ostream_joiner object, deducing the template's type
   make_ostream_joiner arguments from the function arguments
                       \fI(function template)\fP

.SH Example


// Run this code

 #include <algorithm>
 #include <experimental/iterator>
 #include <iostream>
 #include <iterator>

 int main()
 {
     int i[] = {1, 2, 3, 4, 5};
     std::copy(std::begin(i),
               std::end(i),
               std::experimental::make_ostream_joiner(std::cout, ", "));
 }

.SH Output:

 1, 2, 3, 4, 5

.SH See also

   ostreambuf_iterator output iterator that writes to std::basic_streambuf
                       \fI(class template)\fP
   ostream_iterator    output iterator that writes to std::basic_ostream
                       \fI(class template)\fP
   istream_iterator    input iterator that reads from std::basic_istream
                       \fI(class template)\fP
